package com.zk.algo;

import java.util.Scanner;

public class DaiShuGuoHe {

    // 39
    // 3 6 6 6 3 8 9 8 5 2 9 7 3 6 5 4 2 3 6 9 9 8 6 4 1 0 4 4 8 9 3 6 0 7 8 1 1 8 4
    //       ↑
    //                   ↑   ↑             ↑           ↑
    //                                               ↑       ↑       ↑           ↑ ↑
    public static void main(String...args) {

        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int[] array = new int[n];
        int i = 0;

        while (i < n) {
            array[i] = scanner.nextInt();
            i++;
        }

        int minJump = findMinJumpCorrect1(array);

        System.out.println(minJump);
    }

    /**
     * 只有我不是用动态规划吗。。。，
     * 感觉可以用贪心，
     * 每次找到离岸最近且能跳过去的弹簧i，
     * 找得到次数+1，
     * 把对岸改为第i个弹簧，
     * 即 n=i，当 n=0 时，
     * 就可以过河，
     * 当n>0时表示不能过河
     *
     * @param array
     * @return
     */
    private static int findMinJumpCorrect1(int[] array) {
        int count = 0;
        int n = array.length;

        for (int i=0; i < n; i++) {

            if (array[i] >= n - i) {
                count++;
                n = i;
                i = -1;
            }

        }

        if (n != 0) {
            count = -1;
        }

        return count;
    }

    private static int findMinJump(int[] array) {

        int result = 0; // 最终结果
        int currMaxCanJump = array[0]; // 当前最多跳多少下
        int currIndex = 0; // 当前所处下标
        int maxIndex = array.length - 1; // 最大索引,当 currIndex 和 最大索引 相同的时候,就认为跳过去了

        while (currIndex != maxIndex) {

            // 当前能跳的最大索引
            int maxJumpIndex = currIndex + currMaxCanJump;
            // 可以跳过去,还需要一跳就过去了
            if (maxJumpIndex >= maxIndex) {
                result++;
                break;
            }

            int currMaxIndex = maxJumpIndex;
            int currMinIndex = currIndex + 1;

            while (array[currMaxIndex] == 0 &&
                    currMaxIndex >= currMinIndex) {
                currMaxIndex--;
            }

            // 没有可跳的
            if (currMaxIndex == currIndex) {
                result = -2;
                break;
            }

            currIndex = currMaxIndex;
            currMaxCanJump = array[currMaxIndex];
            result++;
        }

        return (++result);
    }

}
